home *** CD-ROM | disk | FTP | other *** search
/ DS-CD ROM 2 1993 August / DS CD-ROM 2.Ausgabe (August 1993).iso / programm / ds0257 / doc.exe / BHEAP.DOC < prev    next >
Text File  |  1992-02-21  |  25KB  |  562 lines
  1.   ─────────────────────────────────────────────────────────────────────────────
  2.   Dokumentation zur Datei: BHEAP.INC
  3.  
  4.   ─────────────────────────────────────────────────────────────────────────────
  5.    
  6.     BHEAP.INC    - Routinen zur Verwaltung eines BasedHeaps
  7.                    (für den Assembler A86)
  8.    
  9.                    (c) Bernd Schemmer 1992
  10.                    Letzter Update: 21.02.1992
  11.    
  12.    
  13.     ■ Beschreibung:
  14.     ---------------
  15.     BHEAP.INC stellt Routinen zur Verwaltung eines BasedHeaps zur Verfügung.
  16.     Ein BasedHeap ist ein Heap (oder auf deutsch: eine Halde), der maximal
  17.     ein Segment (= 65.535 Byte) groß sein kann und nur mit Offset-Werten für
  18.     die Zeiger arbeitet.
  19.     Die minimale Größe für den BasedHeap ist ein Kilobyte (1.024 Byte).
  20.     Jeder Speicherblock auf dem BasedHeap belegt immer ein Vielfaches von
  21.     4 Byte plus 4 Byte zur Verwaltung des Blocks. Die maximale Länge eines
  22.     Blocks ist gleich dem maximalen freien Platz auf dem BasedHeap.
  23.     Es ist auch ein sequentielles Durchlaufen der Blöcke auf dem BasedHeap,
  24.     in beliebiger Richtung und ab einem beliebigen Block, möglich.
  25.     Das Vergrößern oder Verkleinern des BasedHeaps ist ebenfalls jederzeit
  26.     möglich.
  27.    
  28.     Der BasedHeap wird von unten nach oben belegt, wobei, falls erwünscht,
  29.     immer zuerst die Löcher im belegten Teil wieder belegt werden. Die
  30.     Behandlung der freien Blöcke, will sagen: Zusammenfassen von freie
  31.     Blöcken oder nicht, ist ebenfalls variabel.
  32.     Die freien Blöcke werden über eine Freiblock-Kette verwaltet. Die
  33.     Freiblock-Kette wird mit einem stack-artigen Algorithmus verwaltet,
  34.     d.h. freie Blöcke werden immer am Anfang der Kette eingefügt und die
  35.     Suche nach freien Blöcken beginnt auch immer am Anfang der Kette.
  36.    
  37.     Die maximal mögliche Anzahl von Elementen auf dem BasedHeap kann bei
  38.     Elementen mit gleicher Länge nach folgender Formel berechnet werden:
  39.    
  40.          n = (HeapLength - 16) DIV ( BlockLength + 4)
  41.    
  42.          mit:
  43.    
  44.          HeapLength  = Größe des Heaps
  45.                        (Parameter der Routine 'InitBHeap', abgerundet
  46.                         auf die nächste 4-Byte-Grenze)
  47.          BlockLength = Größe der zu belegenden Blöcke auf dem Heap
  48.    
  49.     Der BasedHeap ist folgendermaßen aufgebaut:
  50.    
  51.     BasedHeapSegment:0         n Byte Verwaltungsdaten für den BasedHeap
  52.     BasedHeapSegment:n         4 Byte für den Control-Block des 1. Blocks
  53.                                auf dem BasedHeap
  54.     BasedHeapSegment:n+4       m1 Byte für den 1. Block auf dem BasedHeap
  55.     BasedHeapSegment:n+4+m1    4 Byte für den Control-Block des 2. Blocks
  56.                                auf dem BasedHeap
  57.     BasedHeapSegment:n+4+m1+4  m2 Byte für den 2. Block auf dem BasedHeap
  58.    
  59.                                ...
  60.    
  61.     BasedHeapSegment:z         4 Byte für den Control-Block des folgenden
  62.                                Blocks
  63.     BasedHeapSegment:z+4       mm Byte für den letzen Block auf dem
  64.                                BasedHeap
  65.    
  66.     Hinweis: Freie Blöcke auf dem BasedHeap dürfen auf keinen Fall
  67.              vom Programm verändert werden, da diese von den Routinen
  68.              zur Verwaltung der Freiblock-Kette verwendet werden.
  69.    
  70.     Dem Nachteil dieses Heap-Konzepts, die Begrenzung des Heaps auf
  71.     maximal ein Segment, stehen mehrere Vorteile gegenüber:
  72.    
  73.     1. Der Overhead an Speicherplatz für die Verwaltung des Heaps ist
  74.        mit 4 Byte pro Block und 16 Byte für den Header minimal.
  75.    
  76.     2. Die gesamte Verwaltung arbeitet mit relativen Offsets. D.h. es
  77.        ist möglich, den BasedHeap in einem Programm zu belegen, diesen
  78.        vor dem Programmende in eine Datei zu sichern und später, z.B.
  79.        nach einem erneuten Programmstart, den gesicherten BasedHeap
  80.        neu zu laden und damit weiter zu arbeiten.
  81.        Die Segment-Adresse des BasedHeaps ist dabei völlig belanglos.
  82.        (Hinweis: Es muß nur der belegte Teil des BasedHeaps gesichert
  83.                  werden. Der Speicherblock für den BasedHeap muß aber
  84.                  immer die gleiche Größe haben!)
  85.    
  86.     3. Da die Adress-Berechnungen in den Routinen zur Verwaltung des
  87.        BasedHeaps und in den Routinen, die den BasedHeap nutzen, nur
  88.        mit Offsets durchgeführt werden, ist die Geschwindigkeit auch
  89.        relativ hoch. (Nebenbei bemerkt: Ein weiterer Steigerung der
  90.        Geschwindigkeit konnte durch die Verwendung von zwei doppelt-
  91.        verketteten Listen zur Verwaltung der Blöcke erreicht werden.)
  92.    
  93.     4. Die Routinen können mit mehreren BasedHeaps gleichzeitig arbeiten,
  94.        da alle Variablen zur Verwaltung des BasedHeaps auf den BasedHeap
  95.        eingerichtet werden.
  96.        Dadurch kann ein Programm z.B. für verschiedene Datentypen
  97.        verschiedene BasedHeaps anlegen. Falls ein BasedHeap nur für
  98.        Datentypen mit gleicher Länge benutzt wird, ist gewährleistet,
  99.        daß die beim Löschen von Elementen entstehenden Löcher immer
  100.        wieder vollständig belegt werden können und somit der Verschnitt
  101.        minimiert wird.
  102.    
  103.    
  104.     ■ Variablen:
  105.     ------------
  106.     BHeapSeg              - Wort, Segment des aktuellen BasedHeaps
  107.    
  108.          Alle Routinen (außer InitBHeap) definieren einen zusätzlichen
  109.          Einsprungpunkt 'name_A'. (z.B. für 'GetBHeapMem' ist dies
  110.          'GetBHeapMem_A'). Falls die Routinen über diesen Einsprungpunkt
  111.          aufgerufen werden, arbeiten sie auf dem BasedHeap, dessen
  112.          Segment in dieser Variable gespeichert ist. (Der Wert des
  113.          Registers ES beim Aufruf ist in diesen Fall ohne Bedeutung,
  114.          das Register ES wird aber NICHT gesichert! Die Variable muß
  115.          in diesem Fall vorher auf einen korrekten Wert gesetzt worden
  116.          sein! (direkt oder durch den Aufruf von 'InitBHeap')
  117.    
  118.          Falls die Routinen über den normalen Einsprungpunkt aufgerufen
  119.          werden, wird diese Variable weder genutzt noch verändert.
  120.    
  121.     BHeapSeg:[BHeapFlags] - Byte, Flags des BasedHeaps
  122.    
  123.          Aufbau des Flag-Bytes:
  124.    
  125.           Bit  | Bedeutung
  126.          ------+-------------------------------------------------------
  127.            0   | Bit = 0 ->> Bei der Belegung von neuen Blöcken
  128.                |             zuerst die Löcher im schon belegten
  129.                |             Teil berücksichtigen.
  130.                | Bit = 1 ->> Bei der Belegung von neuen Blöcken
  131.                |             zuerst versuchen, den Block hinter den
  132.                |             schon belegten Blöcken anzulegen.
  133.                |
  134.            1   | Bit = 0 ->> Bei der Freigabe von Blöcken aufeinander
  135.                |             folgende freie Blöcke sofort nach der
  136.                |             Freigabe zusammenfügen.
  137.                | Bit = 1 ->> Aufeinander folgende freie Blöcke nach der
  138.                |             Freigabe nicht zusammenfügen. Dies ist
  139.                |             z.B. sinnvoll, falls alle Elemente auf dem
  140.                |             BasedHeap die gleiche Länge haben.
  141.                |
  142.          2 - 7 | reserviert, sollten 0 sein
  143.                |
  144.    
  145.          Die Flags werden von der Routine 'InitBHeap' mit 0 vorbelegt.
  146.          Die Routine 'RepairBHeap' setzt, falls eine Reparatur durch-
  147.          geführt wird, die Flags ebenfalls auf 0.
  148.          Die Flags können zu beliebigen Zeitpunkten geändert werden.
  149.    
  150.     BHeapSeg:[BHeapUserData1] - Wort, für Benutzerzwecke reserviert
  151.     BHeapSeg:[BHeapUserData2] - Wort, für Benutzerzwecke reserviert
  152.    
  153.          An den Offsets BHeapUserData1 und BHeapUserData2 im Header
  154.          des BasedHeaps sind jeweils 2 Byte (= 1 Wort) für Daten des
  155.          Programms reserviert. Diese beiden Wörter werden von den
  156.          Routinen zur Verwaltung des BasedHeaps weder gelesen noch
  157.          verändert (also auch nicht mit einem bestimmten Wert initi-
  158.          alisiert).
  159.          (BHeapUserData1 und BHeapUserData2 sind über 'dw' definiert)
  160.    
  161.    
  162.     Alle anderen Variablen zur Verwaltung des BasedHeaps werden auf
  163.     dem BasedHeap angelegt und sollten von anderen Routinen weder
  164.     gelesen noch verändert werden!
  165.    
  166.    
  167.     ■ Routinen:
  168.     -----------
  169.     InitBHeap             - Initialisert (d.h. löscht) den BasedHeap
  170.    
  171.     !! Alle weiteren Routinen können erst benutzt werden, falls !!
  172.     !! entweder 'InitBHeap' aufgerufen wurde oder der BasedHeap !!
  173.     !! anderweitig eingerichtet wurde (z.B. durch Lesen aus     !!
  174.     !! einer Datei).                                            !!
  175.    
  176.     GetBHeapMem           - Belegt einen Block auf dem BasedHeap
  177.     FreeBHeapMem          - Gibt einen belegten Block wieder frei
  178.     ReleaseBHeapMem       - Gibt alle Blöcke ab einem Block frei
  179.    
  180.     GetBHeapBlockLength   - Ermittelt die Länge eines Blocks
  181.    
  182.     GetFirstBHeapBlock    - Ermittelt den ersten Block
  183.     GetLastBHeapBlock     - Ermittelt den letzten Block
  184.    
  185.     GetNextBHeapBlock     - Ermittelt den nächsten Block
  186.     GetPrevBHeapBlock     - Ermittelt den vorherigen Block
  187.    
  188.     GetBHeapMemAvail      - Ermittelt den freien Speicherplatz und
  189.                             die Länge des größten freien Blocks
  190.    
  191.     GetMaxBHeapPointer    - Ermittelt die Größe des belegten Teils des
  192.                             BasedHeaps
  193.    
  194.     ChangeBHeapSize       - Vergrößert oder verkleinert den BasedHeap
  195.    
  196.     ChainFreeBHeapBlocks  - Faßt alle benachbarten freien Blöcke in
  197.                             jeweils einen großen freien Block zusammen.
  198.    
  199.     RepairBHeap           - Repariert den BasedHeap
  200.    
  201.          Der Aufruf der Routine 'RepairBHeap' ist notwendig, falls ein
  202.          Teil der Verwaltungsdaten des BasedHeaps überschrieben wurden.
  203.          In diesem Fall versucht 'RepairBHeap' den Fehler zu beseitigen
  204.          um eventuelle Datenverluste zu minimieren.
  205.    
  206.          'RepairBHeap' sollte aufgerufen werden, falls eine Routine die
  207.          Fehlernummer für 'fataler Fehler' zurückliefert.
  208.          Falls 'RepairBHeap' selbst diesen Fehler zurückliefert, ist
  209.          eine Reparatur des BasedHeaps nicht mehr möglich!
  210.          'RepairBHeap' sollte auch aufgerufen werden, falls eine Routine
  211.          unerwarteterweise die Fehlernummer für 'kein korrekter Zeiger
  212.          angegeben' oder die Fehlernnumer für 'Fehler in der Kette der
  213.          freien Blöcke' zurückliefert. In diesen Fall kann 'RepairBHeap'
  214.          den Fehler fast in allen Fällen korrigieren, wobei bei einem
  215.          Einzelfehler (d.h. nur ein Control-Block ist defekt), maximal
  216.          3 Blöcke des BasedHeaps verloren gehen.
  217.    
  218.     Die Routinen überprüfen immer, ob der Header des BasedHeaps verändert
  219.     wurde und, falls ein Zeiger angegeben ist, ob dieser korrekt ist.
  220.    
  221.     Die Routinen benutzen das Register AX als Arbeitssregister.
  222.     Falls die Routinen über den Einsprungpunkt 'name_A' aufgerufen werden,
  223.     wird auch das Register ES verändert.
  224.    
  225.     Hinweis: Da nicht alle verwendeten Namen und Bezeichner dieser Datei
  226.              dokumentiert sind, sollten bei Nutzung dieser Routinen in
  227.              den anderen Quelltexten keine Namen oder Bezeichner, die
  228.              die Zeichenkette 'BHeap' oder 'BH_' enthalten, verwendet
  229.              werden.
  230.    
  231.    
  232.    
  233.     ■ EQUs für die Flags des BasedHeaps
  234.    
  235.     TryLastPtrFirst  EQU 001h   ; neue Blöcke zuerst hinter den belegten
  236.                                 ; Blöcken anlegen (log. Operation: OR )
  237.    
  238.     FreePtrFirst     EQU 0FEh   ; für neue Blöcke zuerst die Löcher belegen
  239.                                 ; (logische Operation: AND)
  240.    
  241.     BigFreeBlocks    EQU 0FDh   ; freie Blöcke sofort zusammenfassen
  242.                                 ; (logische Operation: AND)
  243.    
  244.     NoBigFreeBlocks  EQU 002h   ; freie Blöcke nicht zusammenfassen
  245.                                 ; (logische Operation: OR)
  246.    
  247.    
  248.     ■ Fehlernummern der Routinen
  249.     ----------------------------
  250.    
  251.     Alle Fehlernummern der Routinen haben das Format 80xx, wobei xx die
  252.     Nummer des eigentlichen Fehlers ist.
  253.    
  254.     Name                   Nummer   Bedeutung
  255.     ----------------------------------------------------------------------
  256.     BHeapFatalError    EQU 080FFh ; Fataler Fehler
  257.                                   ; Der Header des BasedHeaps ist defekt.
  258.                                   ; In diesem Fall sollte versucht werden,
  259.                                   ; den Fehler durch die Routine 'Repair-
  260.                                   ; BHeap' zu korrigieren (s.o.).
  261.    
  262.     BHeapPointerError  EQU 080FEh ; Der angegebene Zeiger zeigt NICHT auf
  263.                                   ; einen BasedHeapBlock. Falls dieser
  264.                                   ; Fehler auftritt, sollte ebenfalls
  265.                                   ; versucht werden, den Fehler durch die
  266.                                   ; Routine 'RepairBHeap' zu korrigieren
  267.                                   ; (s.o.).
  268.    
  269.     BHeapFPointerError EQU 080FDh ; Fehler in der Kette der freien Blöcke
  270.                                   ; Falls dieser Fehler auftritt, kann er
  271.                                   ; immer über die Routine 'RepairBHeap'
  272.                                   ; behoben werden (s.o.).
  273.    
  274.     BHeapLengthError   EQU 080FCh ; Falsche Größe für den BasedHeap
  275.                                   ; angegeben.
  276.                                   ; Der Fehler wird nur von den Routinen
  277.                                   ; 'InitBHeap' und 'ChangeBHeapSize'
  278.                                   ; zurückgeliefert.
  279.    
  280.     BHeapNoMoreBlocks  EQU 08001h ; Keine weiteren Blöcke vorhanden
  281.                                   ; Fehlernummer der Routinen 'GetNext-
  282.                                   ; BHeapBlock' und 'GetPrevBHeapBlock'
  283.                                   ; falls der letzte bzw. erste Block
  284.                                   ; erreicht wurde.
  285.    
  286.     BHeapFreeBLError   EQU 08002h ; Freizugebender Block ist schon frei.
  287.    
  288.     BHeapMemoryError   EQU 08003h ; Ein Block mit der angeforderten Größe
  289.                                   ; ist nicht mehr verfügbar.
  290.    
  291.     BHeapRepaired      EQU 08004h ; Fehlernummer der Routine 'RepairBHeap',
  292.                                   ; falls die Reparatur geglückt ist.
  293.    
  294.    
  295.    
  296.     ----------------------------
  297.     ChainFreeBHeapBlocks
  298.    
  299.     Funktion: Zusammenfaßen aller benachbarten freien Blöcke zu
  300.               jeweils einem großen freien Block
  301.    
  302.     Eingabe:  ES = Segment des BasedHeaps
  303.    
  304.     Ausgabe:  CF = 0 ->> okay
  305.               CF = 1 ->> Fehler
  306.                          AX = Fehlernummer
  307.    
  308.    
  309.     ----------------------------
  310.     ChangeBHeapSize
  311.    
  312.     Funktion: Vergrößert oder verkleinert den BasedHeap
  313.    
  314.     Eingabe:  CX = neue Größe für den BasedHeap in Byte (incl. Header)
  315.                    Falls CX = 0 ist, gibt die Routine nur die aktuelle
  316.                    gesamte Größe des BasedHeaps im Register AX zurück
  317.                    (incl. Header).
  318.                    Es muß gelten: 1.024xD <= CX <= 65.535xD
  319.                              und:  CX >= belegter_Teil_des_BasedHeaps
  320.    
  321.     Ausgabe:  CF = 0 ->> okay
  322.                          AX = neue Größe des BasedHeaps (incl. Header)
  323.               CF = 1 ->> Fehler
  324.                          AX = Fehlernummer
  325.                          Die Größe des BasedHeap wurde nicht verändert.
  326.    
  327.     Bes.:     Die neue Größe wird immer auf einen durch 4 teilbaren
  328.               Wert abgerundet.
  329.               Der BasedHeap kann nur soweit verkleinert werden, daß
  330.               keine belegten Blöcke verloren gehen.
  331.               Die eigentliche Änderung der Blockgröße (falls der Block
  332.               z.B. über DOS allociert wurde) muß die aufrufende Routine
  333.               in folgender Reihenfolge durchführen:
  334.    
  335.               1. Verkleinern                 | 2. Vergrößern
  336.               -------------------------------+---------------------------
  337.               mov cx,Shorter_NewSize         | mov cx,Bigger_NewSize
  338.               call ChangeBHeapSize_A         | ; Speicherblock vergrößern
  339.               jc Fehler                      | call ChangeBHeapSize_A
  340.               ; Speicherblock verkleinern    | jc Fehler
  341.    
  342.     ----------------------------
  343.     InitBHeap
  344.    
  345.     Funktion: Initialisiert (d.h. löscht) den gesamten BasedHeap
  346.    
  347.     Eingabe:  ES = Segment des BasedHeaps
  348.                    Der BasedHeap beginnt immer mit dem Header am
  349.                    Offset 0 im angegebenen Segment.
  350.               CX = Länge des BasedHeaps in Byte
  351.                    (incl. Verwaltungsdaten)
  352.                    Es muß gelten: 1.024xD <= CX <= 65.535xD
  353.    
  354.     Ausgabe:  CF = 0 ->> okay
  355.                          AX = freier Speicher auf dem BasedHeap
  356.                          Die Variable BHeapSeg wird gesetzt.
  357.               CF = 1 ->> Fehler
  358.                          AX = Fehlernummer
  359.                          Die Variable BHeapSeg wird nicht verändert.
  360.    
  361.     Bes.:     Der Speicherbereich für den BasedHeap muß vorher schon
  362.               allociert worden sein! Die angegebene Länge beinhaltet
  363.               auch die Kontroll-Strukturen (Header und Control-Blocks)
  364.               für den BasedHeap, d.h. der in AX zurückgegebene Wert
  365.               ist immer bis zu 23 Byte kleiner als der Wert in CX.
  366.    
  367.     ----------------------------
  368.     GetBHeapBlockLength
  369.    
  370.     Funktion: Ermittelt die Länge eines Blocks
  371.    
  372.     Eingabe:  ES:BX -> Block
  373.    
  374.     Ausgabe:  CF = 0 ->> okay
  375.                          CX = Länge des Blocks
  376.               CF = 1 ->> Fehler
  377.                          AX = Fehlernummer
  378.    
  379.     ----------------------------
  380.     GetFirstBHeapBlock
  381.    
  382.     Funktion: Ermittelt den ersten Block auf dem BasedHeap
  383.    
  384.     Eingabe:  ES = Segment des BasedHeaps
  385.    
  386.     Ausgabe:  CF = 0 ->> okay
  387.                          ES:BX -> erster Block auf dem BasedHeap
  388.                          CX = Länge des Blocks
  389.                          ZF = 1 ->> Block ist frei
  390.                                     Freie Blöcke dürfen NICHT verändert
  391.                                     werden!
  392.                          ZF = 0 ->> Block ist belegt
  393.               CF = 1 ->> Fehler
  394.                          AX = Fehlernummer
  395.    
  396.     ----------------------------
  397.     GetNextBHeapBlock
  398.    
  399.     Funktion: Ermittelt den nächsten Block auf dem BasedHeap
  400.    
  401.     Eingabe:  ES:BX -> BasedHeapBlock
  402.    
  403.     Ausgabe:  CF = 0 ->> okay
  404.                          ES:BX -> nächster Block auf dem BasedHeap
  405.                          CX = Länge des Blocks
  406.                          ZF = 1 ->> Block ist frei
  407.                                     Freie Blöcke dürfen NICHT verändert
  408.                                     werden!
  409.                          ZF = 0 ->> Block ist belegt
  410.               CF = 1 ->> Fehler
  411.                          AX = Fehlernummer
  412.    
  413.     ----------------------------
  414.     GetPrevBHeapBlock
  415.    
  416.     Funktion: Ermittelt den vorherigen Block auf dem BasedHeap
  417.    
  418.     Eingabe:  ES:BX -> BasedHeapBlock
  419.    
  420.     Ausgabe:  CF = 0 ->> okay
  421.                          ES:BX -> vorheriger Block auf dem BasedHeap
  422.                          CX = Länge des Blocks
  423.                          ZF = 1 ->> Block ist frei
  424.                                     Freie Blöcke dürfen NICHT verändert
  425.                                     werden!
  426.                          ZF = 0 ->> Block ist belegt
  427.               CF = 1 ->> Fehler
  428.                          AX = Fehlernummer
  429.    
  430.     ----------------------------
  431.     GetLastBHeapBlock
  432.    
  433.     Funktion: Ermittelt den letzten Block auf dem BasedHeap
  434.    
  435.     Eingabe:  ES = Segment des BasedHeaps
  436.    
  437.     Ausgabe:  CF = 0 ->> Okay
  438.                          ES:BX -> letzter Block auf dem BasedHeap
  439.                          CX = Länge des Blocks
  440.                          ZF = 1 ->> Block ist frei
  441.                                     Freie Blöcke dürfen NICHT verändert
  442.                                     werden!
  443.                          ZF = 0 ->> Block ist belegt
  444.               CF = 1 ->> Fehler
  445.                          AX = Fehlernummer
  446.    
  447.     ----------------------------
  448.     GetMaxBHeapPointer
  449.    
  450.     Funktion: Ermittelt die Länge des benutzten Teils des BasedHeaps
  451.    
  452.     Eingabe:  ES = Segment des BasedHeaps
  453.    
  454.     Ausgabe:  CF = 0 ->> okay
  455.                          AX = Länge des benutzten Teils des BasedHeaps
  456.               CF = 1 ->> Fehler
  457.                          AX = Fehlernummer
  458.    
  459.     Bes.:     Falls der BasedHeap in eine Datei gesichert werden soll,
  460.               müssen nur die ersten n Byte gesichert werden, wobei
  461.               n der von dieser Routine bei erfolgreicher Ausführung
  462.               im Register AX zurückgegebene Wert ist.
  463.    
  464.     ----------------------------
  465.     GetBHeapMemAvail
  466.    
  467.     Funktion: Ermittelt den freien Speicherplatz auf dem BasedHeap
  468.    
  469.     Eingabe:  ES = Segment des BasedHeaps
  470.    
  471.     Ausgabe:  CF = 0 ->> okay
  472.                          CX = Größe des größten freien Blocks in Byte
  473.                          DX = Gesamt-Größe des freien Speichers in Byte
  474.                          AX = Anzahl der freien Blöcke
  475.               CF = 1 ->> Fehler
  476.                          AX = Fehlernummer
  477.    
  478.     ----------------------------
  479.     ReleaseBHeapMem
  480.    
  481.     Funktion: Freigabe aller Speicherblöcke ab einem vorgegebenen
  482.               Speicherblock
  483.    
  484.     Eingabe:  ES:BX -> erster freizugebender Speicherblock
  485.    
  486.     Ausgabe:  CF = 0 ->> okay
  487.               CF = 1 ->> Fehler
  488.                          AX = Fehlernummer
  489.    
  490.     Hinweis:  Falls der gesamte BasedHeap gelöscht werden soll, sollte
  491.               die Routine 'InitBHeap' verwendet werden.
  492.               Der erste freizugebende Block kann, genau wie die folgenden
  493.               Blöcke auch, ein freier oder ein belegter Block sein.
  494.    
  495.     Bes.:     Freie Blöcke dürfen NICHT verändert werden!
  496.    
  497.               Alle freigegebenen Blöcke werden, unabhängig vom Flag-Bit,
  498.               zu einem Block zusammen gefaßt.
  499.    
  500.     ----------------------------
  501.     FreeBHeapMem
  502.    
  503.     Funktion: Freigabe eines Blocks auf dem BasedHeap
  504.    
  505.     Eingabe:  ES:BX -> freizugebender Block
  506.    
  507.     Ausgabe:  CF = 0 ->> okay
  508.               CF = 1 ->> Fehler
  509.                          AX = Fehlernummer
  510.    
  511.     Bes.:     Freie Blöcke dürfen NICHT verändert werden!
  512.    
  513.     ----------------------------
  514.     GetBHeapMem
  515.    
  516.     Funktion: Belegen eines Blocks auf dem BasedHeap
  517.    
  518.     Eingabe:  ES = Segment des BasedHeaps
  519.               CX = Größe für den Block
  520.    
  521.     Ausgabe:  CF = 0 ->> okay
  522.                          BX = Offset des Blocks
  523.                          CX = Größe des belegten Blocks
  524.               CF = 1 ->> Fehler
  525.                          AX = Fehlernummer
  526.                          BX undefiniert
  527.    
  528.     Bes.:     Die angegebene Größe des Blocks wird immer auf einen durch 4
  529.               teilbaren Wert aufgerundet.
  530.    
  531.     ----------------------------
  532.     RepairBHeap
  533.    
  534.     Funktion: Versucht, den BasedHeap zu reparieren
  535.               Dies ist nötig, falls ein Programm einen oder mehrere
  536.               Control-Blöcke oder den Header überschrieben hat.
  537.               (->> Fehler BHeapFatalError, BHeapPointerError oder
  538.                    BHeapFPointerError)
  539.    
  540.     Eingabe:  ES = BasedHeap-Segment
  541.    
  542.     Ausgabe:  CF = 0 ->> BasedHeap ist in Ordnung
  543.               CF = 1 ->> BasedHeap war nicht in Ordnung
  544.                          AX = Fehlernummer
  545.                          möglich sind hier nur folgende Fehler:
  546.                          AX = BHeapFatalError
  547.                               ->> BasedHeap kann nicht mehr repariert werden
  548.                          AX = BHeapRepaired
  549.                               ->> BasedHeap wurde repariert
  550.                                   BX -> neuer belegter 'MüllBlock'
  551.                                         Dieser Block enthält aller wahr-
  552.                                         scheinlichkeit nur Datenmüll und
  553.                                         sollte freigegeben werden
  554.                                   Die Variable BHeapFlags wurde auf 0
  555.                                   gesetzt.
  556.    
  557.     Bes.:     Falls nur der Header einen korrigierbaren Fehler enthält,
  558.               gibt die Routine CF = 0 zurück.
  559.               Falls nur die Kette der freien Blöcke fehlerhaft war,
  560.               gibt die Routine ebenfalls CF = 0 zurück.
  561.    
  562.